package com.rickpan.service;

import com.rickpan.dto.request.GenerateReportRequest;
import com.rickpan.dto.response.WorkRecordResponse;
import com.rickpan.dto.siliconflow.SiliconFlowRequest;
import com.rickpan.entity.GeneratedReport;
import com.rickpan.entity.UserApiKey;
import com.rickpan.exception.BusinessException;
import com.rickpan.repository.GeneratedReportRepository;
import com.rickpan.repository.UserApiKeyRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * 工作报告AI生成服务
 */
@Service
public class WorkReportGenerationService {

    private static final Logger logger = LoggerFactory.getLogger(WorkReportGenerationService.class);

    @Autowired
    private WorkRecordService workRecordService;

    @Autowired
    private SiliconFlowClient siliconFlowClient;

    @Autowired
    private UserApiKeyRepository userApiKeyRepository;

    @Autowired
    private GeneratedReportRepository generatedReportRepository;

    /**
     * 生成日报
     * @param userId 用户ID
     * @param date 日期
     * @return 生成的日报内容
     */
    @Transactional
    public String generateDailyReport(Long userId, LocalDate date) {
        return generateDailyReport(userId, date, null);
    }

    /**
     * 生成日报（带设置参数）
     * @param userId 用户ID
     * @param date 日期
     * @param request 生成设置参数
     * @return 生成的日报内容
     */
    @Transactional
    public String generateDailyReport(Long userId, LocalDate date, GenerateReportRequest request) {
        logger.info("生成日报，用户ID: {}, 日期: {}", userId, date);

        // 获取当日工作记录
        List<WorkRecordResponse> records = workRecordService.getWorkRecordsByDate(userId, date);

        if (records.isEmpty()) {
            throw new BusinessException("当日无工作记录，无法生成日报");
        }

        // 构建提示词
        String prompt = buildDailyReportPrompt(date, records, request);

        // 调用AI生成报告
        String aiContent = generateReportWithAI(userId, prompt, request);

        // 不再自动保存，由前端控制保存时机
        return aiContent;
    }

    /**
     * 生成周报
     * @param userId 用户ID
     * @param startDate 周开始日期
     * @param endDate 周结束日期
     * @return 生成的周报内容
     */
    @Transactional
    public String generateWeeklyReport(Long userId, LocalDate startDate, LocalDate endDate) {
        return generateWeeklyReport(userId, startDate, endDate, null);
    }

    /**
     * 生成周报（带设置参数）
     * @param userId 用户ID
     * @param startDate 周开始日期
     * @param endDate 周结束日期
     * @param request 生成设置参数
     * @return 生成的周报内容
     */
    @Transactional
    public String generateWeeklyReport(Long userId, LocalDate startDate, LocalDate endDate, GenerateReportRequest request) {
        logger.info("生成周报，用户ID: {}, 开始日期: {}, 结束日期: {}", userId, startDate, endDate);

        // 获取周内工作记录
        List<WorkRecordResponse> records = workRecordService.getWorkRecordsByDateRange(userId, startDate, endDate);

        if (records.isEmpty()) {
            throw new BusinessException("指定时间范围内无工作记录，无法生成周报");
        }

        // 构建提示词
        String prompt = buildWeeklyReportPrompt(startDate, endDate, records, request);

        // 调用AI生成报告
        String aiContent = generateReportWithAI(userId, prompt, request);

        // 不再自动保存，由前端控制保存时机
        return aiContent;
    }

    /**
     * 生成月报
     * @param userId 用户ID
     * @param startDate 月开始日期
     * @param endDate 月结束日期
     * @return 生成的月报内容
     */
    @Transactional
    public String generateMonthlyReport(Long userId, LocalDate startDate, LocalDate endDate) {
        return generateMonthlyReport(userId, startDate, endDate, null);
    }

    /**
     * 生成月报（带设置参数）
     * @param userId 用户ID
     * @param startDate 月开始日期
     * @param endDate 月结束日期
     * @param request 生成设置参数
     * @return 生成的月报内容
     */
    @Transactional
    public String generateMonthlyReport(Long userId, LocalDate startDate, LocalDate endDate, GenerateReportRequest request) {
        logger.info("生成月报，用户ID: {}, 开始日期: {}, 结束日期: {}", userId, startDate, endDate);

        // 获取月内工作记录
        List<WorkRecordResponse> records = workRecordService.getWorkRecordsByDateRange(userId, startDate, endDate);

        if (records.isEmpty()) {
            throw new BusinessException("指定时间范围内无工作记录，无法生成月报");
        }

        // 构建提示词
        String prompt = buildMonthlyReportPrompt(startDate, endDate, records, request);

        // 调用AI生成报告
        String aiContent = generateReportWithAI(userId, prompt, request);

        // 不再自动保存，由前端控制保存时机
        return aiContent;
    }

    /**
     * 保存生成的报告到历史记录
     * @param userId 用户ID
     * @param reportType 报告类型
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @param content 报告内容
     * @param title 报告标题（可选）
     * @return 保存的报告ID
     */
    @Transactional
    public Long saveReportToHistory(Long userId, GeneratedReport.ReportType reportType,
                                   LocalDate startDate, LocalDate endDate,
                                   String content, String title) {
        logger.info("保存报告到历史记录，用户ID: {}, 报告类型: {}", userId, reportType);

        return saveGeneratedReport(userId, reportType, startDate, endDate, content, title);
    }

    /**
     * 构建日报提示词
     */
    private String buildDailyReportPrompt(LocalDate date, List<WorkRecordResponse> records) {
        return buildDailyReportPrompt(date, records, null);
    }

    /**
     * 构建日报提示词（带设置参数）
     */
    private String buildDailyReportPrompt(LocalDate date, List<WorkRecordResponse> records, GenerateReportRequest request) {
        StringBuilder prompt = new StringBuilder();

        // 根据用户设置调整提示词风格
        String style = request != null && request.getStyle() != null ? request.getStyle() : "professional";
        List<String> includeContent = request != null && request.getIncludeContent() != null ?
            request.getIncludeContent() : java.util.Arrays.asList("summary", "achievements", "nextSteps");

        // 风格化的开头
        switch (style) {
            case "casual":
                prompt.append("你是一位友好的工作伙伴，请根据以下工作记录生成一份轻松随意但内容完整的工作日报。\n\n");
                break;
            case "detailed":
                prompt.append("你是一位资深的项目分析师，请根据以下工作记录生成一份详细全面、深入分析的工作日报。\n\n");
                break;
            case "concise":
                prompt.append("你是一位高效的管理者，请根据以下工作记录生成一份简洁明了、突出重点的工作日报。\n\n");
                break;
            default: // professional
                prompt.append("你是一位专业的工作报告撰写专家，请根据以下工作记录生成一份高质量的工作日报。\n\n");
                break;
        }
        prompt.append("## 报告日期\n");
        prompt.append(date.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"))).append("\n\n");
        
        prompt.append("## 工作记录详情\n");

        // 按分类分组显示
        Map<String, List<WorkRecordResponse>> recordsByCategory = records.stream()
                .collect(Collectors.groupingBy(r -> r.getCategoryName() != null ? r.getCategoryName() : "其他"));

        for (Map.Entry<String, List<WorkRecordResponse>> entry : recordsByCategory.entrySet()) {
            prompt.append("### ").append(entry.getKey()).append("\n");
            for (WorkRecordResponse record : entry.getValue()) {
                prompt.append("- **").append(record.getTitle()).append("**\n");
                if (record.getContent() != null && !record.getContent().isEmpty()) {
                    prompt.append("  - 详情：").append(record.getContent()).append("\n");
                }
                prompt.append("  - 状态：").append(record.getStatusDescription());
                prompt.append(" | 优先级：").append(record.getPriorityDescription());
                if (record.getTimeSpent() != null && record.getTimeSpent() > 0) {
                    prompt.append(" | 耗时：").append(record.getTimeSpent()).append("分钟");
                }
                prompt.append("\n\n");
            }
        }

        // 统计信息
        long completedCount = records.stream().filter(r -> "已完成".equals(r.getStatusDescription())).count();
        long inProgressCount = records.stream().filter(r -> "进行中".equals(r.getStatusDescription())).count();
        int totalTimeSpent = records.stream().mapToInt(r -> r.getTimeSpent() != null ? r.getTimeSpent() : 0).sum();

        prompt.append("## 统计数据\n");
        prompt.append("- 总工作项：").append(records.size()).append("项\n");
        prompt.append("- 已完成：").append(completedCount).append("项\n");
        prompt.append("- 进行中：").append(inProgressCount).append("项\n");
        prompt.append("- 总耗时：").append(totalTimeSpent).append("分钟（约").append(String.format("%.1f", totalTimeSpent / 60.0)).append("小时）\n\n");

        prompt.append("## 生成要求\n");

        // 根据风格调整语言要求
        String styleDescription = "";
        switch (style) {
            case "casual":
                styleDescription = "语言轻松自然，可以使用一些口语化表达，但保持内容的完整性";
                break;
            case "detailed":
                styleDescription = "语言详细严谨，提供深入分析和具体细节，包含数据分析和趋势判断";
                break;
            case "concise":
                styleDescription = "语言简洁明了，直击要点，避免冗余，突出关键信息";
                break;
            default: // professional
                styleDescription = "语言简洁专业，避免冗余表述，突出工作成果和价值贡献";
                break;
        }

        prompt.append("请基于以上信息生成一份工作日报，要求：\n\n");
        prompt.append("1. **直接输出Markdown内容**，不要使用代码块包裹\n");
        prompt.append("2. **使用标准Markdown格式**，包含清晰的标题层级\n");
        prompt.append("3. **结构要求**，包含以下部分：\n");
        prompt.append("   - # 工作日报 - [日期]\n");

        // 根据用户选择的包含内容动态生成结构要求
        if (includeContent.contains("summary")) {
            prompt.append("   - ## 📊 今日概览（包含关键数据和工作总结）\n");
        }
        if (includeContent.contains("achievements")) {
            prompt.append("   - ## ✅ 主要完成事项（按重要性排序，突出成果）\n");
        }
        if (includeContent.contains("challenges")) {
            prompt.append("   - ## ⚠️ 遇到的挑战（问题分析和解决思路）\n");
        }
        if (includeContent.contains("nextSteps")) {
            prompt.append("   - ## 📋 明日工作计划（具体可执行的任务）\n");
        }
        if (includeContent.contains("improvements")) {
            prompt.append("   - ## 💡 改进建议（工作方法和流程优化）\n");
        }

        prompt.append("4. **内容要求**：\n");
        prompt.append("   - ").append(styleDescription).append("\n");
        prompt.append("   - 数据化表达，使用具体数字和统计信息\n");
        prompt.append("   - 合理使用Emoji增强可读性\n");
        prompt.append("   - 如果某个部分没有内容，可以简要说明或省略\n\n");
        prompt.append("**重要提醒：请直接输出Markdown格式的报告内容，不要使用```markdown代码块包裹，不要添加任何前缀或后缀说明。**");

        return prompt.toString();
    }

    /**
     * 构建周报提示词
     */
    private String buildWeeklyReportPrompt(LocalDate startDate, LocalDate endDate, List<WorkRecordResponse> records) {
        return buildWeeklyReportPrompt(startDate, endDate, records, null);
    }

    /**
     * 构建周报提示词（带设置参数）
     */
    private String buildWeeklyReportPrompt(LocalDate startDate, LocalDate endDate, List<WorkRecordResponse> records, GenerateReportRequest request) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("你是一位资深的项目管理专家，请根据以下工作记录生成一份高质量的工作周报。\n\n");
        prompt.append("## 报告周期\n");
        prompt.append(startDate.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")))
              .append(" 至 ").append(endDate.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"))).append("\n\n");

        // 按日期分组工作记录
        Map<LocalDate, List<WorkRecordResponse>> recordsByDate = records.stream()
                .collect(Collectors.groupingBy(WorkRecordResponse::getDate));

        prompt.append("本周工作记录：\n");
        recordsByDate.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .forEach(entry -> {
                    LocalDate date = entry.getKey();
                    List<WorkRecordResponse> dayRecords = entry.getValue();
                    
                    prompt.append("\n").append(date.format(DateTimeFormatter.ofPattern("MM月dd日"))).append("：\n");
                    for (WorkRecordResponse record : dayRecords) {
                        prompt.append("- ").append(record.getTitle());
                        if (record.getCategoryName() != null) {
                            prompt.append("（").append(record.getCategoryName()).append("）");
                        }
                        prompt.append(" - ").append(record.getStatusDescription()).append("\n");
                    }
                });

        // 统计信息
        long completedCount = records.stream().filter(r -> "已完成".equals(r.getStatusDescription())).count();
        int totalTimeSpent = records.stream().mapToInt(r -> r.getTimeSpent() != null ? r.getTimeSpent() : 0).sum();

        prompt.append("\n\n统计信息：\n");
        prompt.append("- 总工作项：").append(records.size()).append("项\n");
        prompt.append("- 已完成：").append(completedCount).append("项\n");
        prompt.append("- 总耗时：").append(totalTimeSpent).append("分钟\n\n");

        // 按分类和优先级分析
        Map<String, List<WorkRecordResponse>> recordsByCategory = records.stream()
                .collect(Collectors.groupingBy(r -> r.getCategoryName() != null ? r.getCategoryName() : "其他"));

        long highPriorityCount = records.stream().filter(r -> "高".equals(r.getPriorityDescription())).count();
        long inProgressCount = records.stream().filter(r -> "进行中".equals(r.getStatusDescription())).count();

        prompt.append("## 详细统计分析\n");
        prompt.append("- 总工作项：").append(records.size()).append("项\n");
        prompt.append("- 已完成：").append(completedCount).append("项（完成率：").append(String.format("%.1f", (double)completedCount/records.size()*100)).append("%）\n");
        prompt.append("- 进行中：").append(inProgressCount).append("项\n");
        prompt.append("- 高优先级：").append(highPriorityCount).append("项\n");
        prompt.append("- 总耗时：").append(totalTimeSpent).append("分钟（约").append(String.format("%.1f", totalTimeSpent / 60.0)).append("小时）\n");
        prompt.append("- 日均工作量：").append(String.format("%.1f", (double)records.size()/7)).append("项\n\n");

        prompt.append("## 分类工作分布\n");
        recordsByCategory.forEach((category, categoryRecords) -> {
            long categoryCompleted = categoryRecords.stream().filter(r -> "已完成".equals(r.getStatusDescription())).count();
            prompt.append("- **").append(category).append("**：").append(categoryRecords.size())
                  .append("项（完成").append(categoryCompleted).append("项）\n");
        });

        prompt.append("\n## 生成要求\n");
        prompt.append("请基于以上信息生成一份专业的工作周报，要求：\n\n");
        prompt.append("1. **直接输出Markdown内容**，不要使用代码块包裹\n");
        prompt.append("2. **使用标准Markdown格式**，包含清晰的标题层级\n");
        prompt.append("3. **结构完整**，包含以下必要部分：\n");
        prompt.append("   - # 工作周报 - [周期]\n");
        prompt.append("   - ## 📊 本周概览（关键数据和趋势）\n");
        prompt.append("   - ## 🎯 主要成果与亮点（按重要性排序）\n");
        prompt.append("   - ## 📈 工作完成情况分析\n");
        prompt.append("   - ## ⚠️ 问题与挑战（如有）\n");
        prompt.append("   - ## 📋 下周工作重点\n");
        prompt.append("   - ## 💡 改进建议（可选）\n");
        prompt.append("4. **内容要求**：\n");
        prompt.append("   - 突出周期性总结和趋势分析\n");
        prompt.append("   - 重点展示完成率和效率数据\n");
        prompt.append("   - 识别工作模式和改进机会\n");
        prompt.append("   - 合理规划下周重点工作\n");
        prompt.append("   - 使用图表化表达（如进度条、百分比）\n\n");
        prompt.append("**重要提醒：请直接输出Markdown格式的报告内容，不要使用```markdown代码块包裹，不要添加任何前缀或后缀说明。**");

        return prompt.toString();
    }

    /**
     * 构建月报提示词
     */
    private String buildMonthlyReportPrompt(LocalDate startDate, LocalDate endDate, List<WorkRecordResponse> records) {
        return buildMonthlyReportPrompt(startDate, endDate, records, null);
    }

    /**
     * 构建月报提示词（带设置参数）
     */
    private String buildMonthlyReportPrompt(LocalDate startDate, LocalDate endDate, List<WorkRecordResponse> records, GenerateReportRequest request) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("你是一位高级管理顾问，请根据以下工作记录生成一份具有战略价值的工作月报。\n\n");
        prompt.append("## 报告月份\n");
        prompt.append(startDate.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日")))
              .append(" 至 ").append(endDate.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"))).append("\n\n");

        // 按分类统计
        Map<String, List<WorkRecordResponse>> recordsByCategory = records.stream()
                .collect(Collectors.groupingBy(r -> r.getCategoryName() != null ? r.getCategoryName() : "其他"));

        prompt.append("本月工作记录（按分类）：\n");
        recordsByCategory.forEach((category, categoryRecords) -> {
            prompt.append("\n").append(category).append("（").append(categoryRecords.size()).append("项）：\n");
            categoryRecords.forEach(record -> {
                prompt.append("- ").append(record.getTitle())
                      .append(" - ").append(record.getStatusDescription()).append("\n");
            });
        });

        // 详细统计
        long completedCount = records.stream().filter(r -> "已完成".equals(r.getStatusDescription())).count();
        long inProgressCount = records.stream().filter(r -> "进行中".equals(r.getStatusDescription())).count();
        int totalTimeSpent = records.stream().mapToInt(r -> r.getTimeSpent() != null ? r.getTimeSpent() : 0).sum();

        prompt.append("\n\n统计分析：\n");
        prompt.append("- 总工作项：").append(records.size()).append("项\n");
        prompt.append("- 已完成：").append(completedCount).append("项（")
              .append(String.format("%.1f", (double) completedCount / records.size() * 100)).append("%）\n");
        prompt.append("- 进行中：").append(inProgressCount).append("项\n");
        prompt.append("- 总工作时长：").append(String.format("%.1f", totalTimeSpent / 60.0)).append("小时\n");
        prompt.append("- 平均每日工作时长：").append(String.format("%.1f", totalTimeSpent / 60.0 / 30)).append("小时\n\n");

        // 按周分析趋势
        Map<Integer, List<WorkRecordResponse>> recordsByWeek = records.stream()
                .collect(Collectors.groupingBy(r -> r.getDate().getDayOfYear() / 7));

        long highPriorityCount = records.stream().filter(r -> "高".equals(r.getPriorityDescription())).count();
        double avgDailyItems = (double) records.size() / 30;
        double avgDailyHours = totalTimeSpent / 60.0 / 30;

        prompt.append("## 深度分析数据\n");
        prompt.append("- 总工作项：").append(records.size()).append("项\n");
        prompt.append("- 完成率：").append(String.format("%.1f", (double) completedCount / records.size() * 100)).append("%\n");
        prompt.append("- 高优先级占比：").append(String.format("%.1f", (double) highPriorityCount / records.size() * 100)).append("%\n");
        prompt.append("- 总工作时长：").append(String.format("%.1f", totalTimeSpent / 60.0)).append("小时\n");
        prompt.append("- 日均工作量：").append(String.format("%.1f", avgDailyItems)).append("项\n");
        prompt.append("- 日均工作时长：").append(String.format("%.1f", avgDailyHours)).append("小时\n");
        prompt.append("- 工作分类数：").append(recordsByCategory.size()).append("个\n\n");

        prompt.append("## 生成要求\n");
        prompt.append("请基于以上信息生成一份高质量的工作月报，要求：\n\n");
        prompt.append("1. **直接输出Markdown内容**，不要使用代码块包裹\n");
        prompt.append("2. **使用标准Markdown格式**，包含清晰的标题层级\n");
        prompt.append("3. **结构完整**，包含以下必要部分：\n");
        prompt.append("   - # 工作月报 - [月份]\n");
        prompt.append("   - ## 📊 月度总览（关键指标和趋势）\n");
        prompt.append("   - ## 🏆 主要成果与里程碑\n");
        prompt.append("   - ## 📈 工作效率分析（完成率、时间分配等）\n");
        prompt.append("   - ## 🔍 分类工作深度分析\n");
        prompt.append("   - ## ⚠️ 问题识别与解决方案\n");
        prompt.append("   - ## 📋 下月工作规划与目标\n");
        prompt.append("   - ## 💡 工作方式优化建议\n");
        prompt.append("4. **内容要求**：\n");
        prompt.append("   - 体现月度总结的战略高度\n");
        prompt.append("   - 深度分析工作模式和效率趋势\n");
        prompt.append("   - 提供数据驱动的洞察和建议\n");
        prompt.append("   - 制定具有前瞻性的下月规划\n");
        prompt.append("   - 使用专业的管理语言和数据可视化表达\n\n");
        prompt.append("**重要提醒：请直接输出Markdown格式的报告内容，不要使用```markdown代码块包裹，不要添加任何前缀或后缀说明。**");

        return prompt.toString();
    }

    /**
     * 使用AI生成报告
     */
    private String generateReportWithAI(Long userId, String prompt) {
        return generateReportWithAI(userId, prompt, null);
    }

    /**
     * 使用AI生成报告（带设置参数）
     */
    private String generateReportWithAI(Long userId, String prompt, GenerateReportRequest request) {
        try {
            // 获取用户API Key
            UserApiKey userApiKey = getUserApiKey(userId);
            if (userApiKey == null) {
                throw new BusinessException("请先配置AI API Key");
            }

            // 确定使用的模型：优先使用请求中的模型，否则使用用户默认模型
            String chatModel = userApiKey.getModel();
            if (request != null && request.getModel() != null && !request.getModel().trim().isEmpty()) {
                chatModel = request.getModel();
                logger.info("使用请求指定的AI模型: {}", chatModel);
            } else if ("Kwai-Kolors/Kolors".equals(chatModel)) {
                chatModel = "THUDM/GLM-4.1V-9B-Thinking"; // 默认聊天模型
                logger.warn("User {} has image model as default, using default chat model for report generation", userId);
            }

            // 获取用户设置的参数
            double temperature = request != null && request.getTemperature() != null ?
                request.getTemperature() : 0.6; // 默认温度
            int maxTokens = request != null && request.getMaxLength() != null ?
                request.getMaxLength() : 2000; // 默认最大长度

            // 构建AI请求
            SiliconFlowRequest aiRequest = SiliconFlowRequest.builder()
                    .model(chatModel)
                    .temperature(temperature)
                    .topP(0.85)
                    .stream(false)
                    .addSystemMessage("你是一位资深的企业管理顾问和报告撰写专家，具有丰富的项目管理和数据分析经验。你的任务是根据工作记录生成高质量、专业的工作报告。\n\n" +
                            "你的专长包括：\n" +
                            "1. 数据分析和趋势识别\n" +
                            "2. 工作效率评估和优化建议\n" +
                            "3. 专业的商务写作和Markdown格式\n" +
                            "4. 战略思维和前瞻性规划\n\n" +
                            "请确保生成的报告：\n" +
                            "- 结构清晰，逻辑严谨\n" +
                            "- 数据准确，分析深入\n" +
                            "- 语言专业，表达简洁\n" +
                            "- 突出重点，体现价值\n" +
                            "- 格式规范，易于阅读\n\n" +
                            "**重要输出要求：**\n" +
                            "- 直接输出Markdown格式的报告内容\n" +
                            "- 不要使用```markdown代码块包裹内容\n" +
                            "- 不要添加任何前缀或后缀说明\n" +
                            "- 确保输出的内容可以直接作为Markdown文档使用")
                    .addUserMessage(prompt)
                    .build();

            // 调用AI API
            String response = siliconFlowClient.sendRequest(userApiKey.getApiKey(), aiRequest);

            logger.info("AI报告生成成功，用户ID: {}, 使用模型: {}", userId, chatModel);
            return response;

        } catch (Exception e) {
            logger.error("AI报告生成失败，用户ID: {}, 错误: {}", userId, e.getMessage(), e);
            throw new BusinessException("AI报告生成失败: " + e.getMessage());
        }
    }

    /**
     * 获取用户API Key
     */
    private UserApiKey getUserApiKey(Long userId) {
        return userApiKeyRepository.findByUserId(userId).orElse(null);
    }

    /**
     * 保存生成的报告到数据库（支持自定义标题，不检查重复）
     * @param userId 用户ID
     * @param type 报告类型
     * @param periodStart 时间范围开始
     * @param periodEnd 时间范围结束
     * @param aiContent AI生成的内容
     * @param customTitle 自定义标题
     * @return 保存的报告ID
     */
    private Long saveGeneratedReport(Long userId, GeneratedReport.ReportType type,
                                   LocalDate periodStart, LocalDate periodEnd,
                                   String aiContent, String customTitle) {
        try {
            // 直接创建新报告，不检查重复
            String title = customTitle != null && !customTitle.trim().isEmpty()
                ? customTitle.trim()
                : GeneratedReport.generateTitle(type, periodStart, periodEnd);

            GeneratedReport newReport = new GeneratedReport(userId, title, type, periodStart, periodEnd, aiContent);

            logger.info("创建新报告，用户ID: {}, 类型: {}, 标题: {}", userId, type, title);
            GeneratedReport saved = generatedReportRepository.save(newReport);
            return saved.getId();
        } catch (Exception e) {
            logger.error("保存报告失败，用户ID: {}, 类型: {}, 错误: {}", userId, type, e.getMessage(), e);
            throw new BusinessException("保存报告失败: " + e.getMessage());
        }
    }

    /**
     * 保存生成的报告到数据库（旧版本，保持兼容性）
     * @param userId 用户ID
     * @param type 报告类型
     * @param periodStart 时间范围开始
     * @param periodEnd 时间范围结束
     * @param aiContent AI生成的内容
     * @return 保存的报告实体
     */
    private GeneratedReport saveGeneratedReport(Long userId, GeneratedReport.ReportType type,
                                              LocalDate periodStart, LocalDate periodEnd, String aiContent) {
        try {
            // 检查是否已存在相同时间范围和类型的报告
            Optional<GeneratedReport> existingReport = generatedReportRepository
                .findByUserIdAndTypeAndPeriodStartAndPeriodEnd(userId, type, periodStart, periodEnd);

            if (existingReport.isPresent()) {
                // 如果已存在，更新版本号和内容
                GeneratedReport report = existingReport.get();
                report.setOriginalContent(aiContent);
                report.setEditedContent(null); // 清空编辑内容
                report.setVersion(report.getVersion() + 1);
                report.setStatus(GeneratedReport.ReportStatus.DRAFT);

                logger.info("更新已存在的报告，报告ID: {}, 新版本: {}", report.getId(), report.getVersion());
                return generatedReportRepository.save(report);
            } else {
                // 创建新报告
                String title = GeneratedReport.generateTitle(type, periodStart, periodEnd);
                GeneratedReport newReport = new GeneratedReport(userId, title, type, periodStart, periodEnd, aiContent);

                logger.info("创建新报告，用户ID: {}, 类型: {}, 标题: {}", userId, type, title);
                return generatedReportRepository.save(newReport);
            }
        } catch (Exception e) {
            logger.error("保存报告失败，用户ID: {}, 类型: {}, 错误: {}", userId, type, e.getMessage(), e);
            // 保存失败不影响报告生成，只记录日志
            return null;
        }
    }
}
